#include "player.h"

 #include "playercontrols.h"
 #include "playlistmodel.h"

 #include <qmediaservice.h>
 #include <qmediaplaylist.h>

 #include <QtGui>

 Player::Player(QWidget *parent)
     : QWidget(parent)
     , videoWidget(0)
     , coverLabel(0)
     , slider(0)
 #ifndef PLAYER_NO_COLOROPTIONS
     , colorDialog(0)
 #endif
 {
     player = new QMediaPlayer(this);
     // owned by PlaylistModel
     playlist = new QMediaPlaylist();
     player->setPlaylist(playlist);

     connect(player, SIGNAL(durationChanged(qint64)), SLOT(durationChanged(qint64)));
     connect(player, SIGNAL(positionChanged(qint64)), SLOT(positionChanged(qint64)));
     connect(player, SIGNAL(metaDataChanged()), SLOT(metaDataChanged()));
     connect(playlist, SIGNAL(currentIndexChanged(int)), SLOT(playlistPositionChanged(int)));
     connect(player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
             this, SLOT(statusChanged(QMediaPlayer::MediaStatus)));
     connect(player, SIGNAL(bufferStatusChanged(int)), this, SLOT(bufferingProgress(int)));
     connect(player, SIGNAL(videoAvailableChanged(bool)), this, SLOT(videoAvailableChanged(bool)));
     connect(player, SIGNAL(error(QMediaPlayer::Error)), this, SLOT(displayErrorMessage()));

     videoWidget = new VideoWidget(this);
     player->setVideoOutput(videoWidget);

     playlistModel = new PlaylistModel(this);
     playlistModel->setPlaylist(playlist);

     playlistView = new QListView(this);
     playlistView->setModel(playlistModel);
     playlistView->setCurrentIndex(playlistModel->index(playlist->currentIndex(), 0));

     connect(playlistView, SIGNAL(activated(QModelIndex)), this, SLOT(jump(QModelIndex)));

     slider = new QSlider(Qt::Horizontal, this);
     slider->setRange(0, player->duration() / 1000);

     labelDuration = new QLabel(this);
     connect(slider, SIGNAL(sliderMoved(int)), this, SLOT(seek(int)));

     QPushButton *openButton = new QPushButton(tr("Open"), this);

     connect(openButton, SIGNAL(clicked()), this, SLOT(open()));

     PlayerControls *controls = new PlayerControls(this);
     controls->setState(player->state());
     controls->setVolume(player->volume());
     controls->setMuted(controls->isMuted());

     connect(controls, SIGNAL(play()), player, SLOT(play()));
     connect(controls, SIGNAL(pause()), player, SLOT(pause()));
     connect(controls, SIGNAL(stop()), player, SLOT(stop()));
     connect(controls, SIGNAL(next()), playlist, SLOT(next()));
     connect(controls, SIGNAL(previous()), this, SLOT(previousClicked()));
     connect(controls, SIGNAL(changeVolume(int)), player, SLOT(setVolume(int)));
     connect(controls, SIGNAL(changeMuting(bool)), player, SLOT(setMuted(bool)));
     connect(controls, SIGNAL(changeRate(qreal)), player, SLOT(setPlaybackRate(qreal)));

     connect(controls, SIGNAL(stop()), videoWidget, SLOT(update()));

     connect(player, SIGNAL(stateChanged(QMediaPlayer::State)),
             controls, SLOT(setState(QMediaPlayer::State)));
     connect(player, SIGNAL(volumeChanged(int)), controls, SLOT(setVolume(int)));
     connect(player, SIGNAL(mutedChanged(bool)), controls, SLOT(setMuted(bool)));

     fullScreenButton = new QPushButton(tr("FullScreen"), this);
     fullScreenButton->setCheckable(true);

 #ifndef PLAYER_NO_COLOROPTIONS
     colorButton = new QPushButton(tr("Color Options..."), this);
     colorButton->setEnabled(false);
     connect(colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
 #endif

     QBoxLayout *displayLayout = new QHBoxLayout;
     displayLayout->addWidget(videoWidget, 2);
     displayLayout->addWidget(playlistView);

     QBoxLayout *controlLayout = new QHBoxLayout;
     controlLayout->setMargin(0);
     controlLayout->addWidget(openButton);
     controlLayout->addStretch(1);
     controlLayout->addWidget(controls);
     controlLayout->addStretch(1);
     controlLayout->addWidget(fullScreenButton);
 #ifndef PLAYER_NO_COLOROPTIONS
     controlLayout->addWidget(colorButton);
 #endif

     QBoxLayout *layout = new QVBoxLayout;
     layout->addLayout(displayLayout);
     QHBoxLayout *hLayout = new QHBoxLayout;
     hLayout->addWidget(slider);
     hLayout->addWidget(labelDuration);
     layout->addLayout(hLayout);
     layout->addLayout(controlLayout);

     setLayout(layout);

     if (!player->isAvailable()) {
         QMessageBox::warning(this, tr("Service not available"),
                              tr("The QMediaPlayer object does not have a valid service.\n"\
                                 "Please check the media service plugins are installed."));

         controls->setEnabled(false);
         playlistView->setEnabled(false);
         openButton->setEnabled(false);
 #ifndef PLAYER_NO_COLOROPTIONS
         colorButton->setEnabled(false);
 #endif
         fullScreenButton->setEnabled(false);
     }

     metaDataChanged();

     QStringList arguments = qApp->arguments();
     arguments.removeAt(0);
     addToPlaylist(arguments);
 }

 Player::~Player()
 {
 }

 void Player::open()
 {
 #ifdef Q_WS_MAEMO_5
     QStringList fileNames;
     QString fileName = QFileDialog::getOpenFileName(this, tr("Open Files"), "/");
     if (!fileName.isEmpty())
         fileNames << fileName;
 #else
     QStringList fileNames = QFileDialog::getOpenFileNames(this, tr("Open Files"));
 #endif
     addToPlaylist(fileNames);
 }

 void Player::addToPlaylist(const QStringList& fileNames)
 {
     foreach (QString const &argument, fileNames) {
         QFileInfo fileInfo(argument);
         if (fileInfo.exists()) {
             QUrl url = QUrl::fromLocalFile(fileInfo.absoluteFilePath());
             if (fileInfo.suffix().toLower() == QLatin1String("m3u")) {
                 playlist->load(url);
             } else
                 playlist->addMedia(url);
         } else {
             QUrl url(argument);
             if (url.isValid()) {
                 playlist->addMedia(url);
             }
         }
     }
 }

 void Player::durationChanged(qint64 duration)
 {
     this->duration = duration/1000;
     slider->setMaximum(duration / 1000);
 }

 void Player::positionChanged(qint64 progress)
 {
     if (!slider->isSliderDown()) {
         slider->setValue(progress / 1000);
     }
     updateDurationInfo(progress / 1000);
 }

 void Player::metaDataChanged()
 {
     //qDebug() << "update metadata" << player->metaData(QtMultimediaKit::Title).toString();
     if (player->isMetaDataAvailable()) {
         setTrackInfo(QString("%1 - %2")
                 .arg(player->metaData(QtMultimediaKit::AlbumArtist).toString())
                 .arg(player->metaData(QtMultimediaKit::Title).toString()));

         if (coverLabel) {
             QUrl url = player->metaData(QtMultimediaKit::CoverArtUrlLarge).value<QUrl>();

             coverLabel->setPixmap(!url.isEmpty()
                     ? QPixmap(url.toString())
                     : QPixmap());
         }
     }
 }

 void Player::previousClicked()
 {
     // Go to previous track if we are within the first 5 seconds of playback
     // Otherwise, seek to the beginning.
     if(player->position() <= 5000)
         playlist->previous();
     else
         player->setPosition(0);
 }

 void Player::jump(const QModelIndex &index)
 {
     if (index.isValid()) {
         playlist->setCurrentIndex(index.row());
         player->play();
     }
 }

 void Player::playlistPositionChanged(int currentItem)
 {
     playlistView->setCurrentIndex(playlistModel->index(currentItem, 0));
 }

 void Player::seek(int seconds)
 {
     player->setPosition(seconds * 1000);
 }

 void Player::statusChanged(QMediaPlayer::MediaStatus status)
 {
     handleCursor(status);

     // handle status message
     switch (status) {
     case QMediaPlayer::UnknownMediaStatus:
     case QMediaPlayer::NoMedia:
     case QMediaPlayer::LoadedMedia:
     case QMediaPlayer::BufferingMedia:
     case QMediaPlayer::BufferedMedia:
         setStatusInfo(QString());
         break;
     case QMediaPlayer::LoadingMedia:
         setStatusInfo(tr("Loading..."));
         break;
     case QMediaPlayer::StalledMedia:
         setStatusInfo(tr("Media Stalled"));
         break;
     case QMediaPlayer::EndOfMedia:
         QApplication::alert(this);
         break;
     case QMediaPlayer::InvalidMedia:
         displayErrorMessage();
         break;
     }
 }

 void Player::handleCursor(QMediaPlayer::MediaStatus status)
 {
 #ifndef QT_NO_CURSOR
     if( status == QMediaPlayer::LoadingMedia ||
         status == QMediaPlayer::BufferingMedia ||
         status == QMediaPlayer::StalledMedia)
         setCursor(QCursor(Qt::BusyCursor));
     else
         unsetCursor();
 #endif
 }

 void Player::bufferingProgress(int progress)
 {
     setStatusInfo(tr("Buffering %4%").arg(progress));
 }

 void Player::videoAvailableChanged(bool available)
 {
     if (!available) {
         disconnect(fullScreenButton, SIGNAL(clicked(bool)),
                     videoWidget, SLOT(setFullScreen(bool)));
         disconnect(videoWidget, SIGNAL(fullScreenChanged(bool)),
                 fullScreenButton, SLOT(setChecked(bool)));
         videoWidget->setFullScreen(false);
     } else {
         connect(fullScreenButton, SIGNAL(clicked(bool)),
                 videoWidget, SLOT(setFullScreen(bool)));
         connect(videoWidget, SIGNAL(fullScreenChanged(bool)),
                 fullScreenButton, SLOT(setChecked(bool)));

         if (fullScreenButton->isChecked())
             videoWidget->setFullScreen(true);
     }
 #ifndef PLAYER_NO_COLOROPTIONS
     colorButton->setEnabled(available);
 #endif
 }

 void Player::setTrackInfo(const QString &info)
 {
     trackInfo = info;
     if (!statusInfo.isEmpty())
         setWindowTitle(QString("%1 | %2").arg(trackInfo).arg(statusInfo));
     else
         setWindowTitle(trackInfo);
 }

 void Player::setStatusInfo(const QString &info)
 {
     statusInfo = info;
     if (!statusInfo.isEmpty())
         setWindowTitle(QString("%1 | %2").arg(trackInfo).arg(statusInfo));
     else
         setWindowTitle(trackInfo);
 }

 void Player::displayErrorMessage()
 {
     setStatusInfo(player->errorString());
 }

 void Player::updateDurationInfo(qint64 currentInfo)
 {
     QString tStr;
     if (currentInfo || duration) {
         QTime currentTime((currentInfo/3600)%60, (currentInfo/60)%60, currentInfo%60, (currentInfo*1000)%1000);
         QTime totalTime((duration/3600)%60, (duration/60)%60, duration%60, (duration*1000)%1000);
         QString format = "mm:ss";
         if (duration > 3600)
             format = "hh:mm:ss";
         tStr = currentTime.toString(format) + " / " + totalTime.toString(format);
     }
     labelDuration->setText(tStr);
 }

 #ifndef PLAYER_NO_COLOROPTIONS
 void Player::showColorDialog()
 {
     if (!colorDialog) {
         QSlider *brightnessSlider = new QSlider(Qt::Horizontal);
         brightnessSlider->setRange(-100, 100);
         brightnessSlider->setValue(videoWidget->brightness());
         connect(brightnessSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setBrightness(int)));
         connect(videoWidget, SIGNAL(brightnessChanged(int)), brightnessSlider, SLOT(setValue(int)));

         QSlider *contrastSlider = new QSlider(Qt::Horizontal);
         contrastSlider->setRange(-100, 100);
         contrastSlider->setValue(videoWidget->contrast());
         connect(contrastSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setContrast(int)));
         connect(videoWidget, SIGNAL(contrastChanged(int)), contrastSlider, SLOT(setValue(int)));

         QSlider *hueSlider = new QSlider(Qt::Horizontal);
         hueSlider->setRange(-100, 100);
         hueSlider->setValue(videoWidget->hue());
         connect(hueSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setHue(int)));
         connect(videoWidget, SIGNAL(hueChanged(int)), hueSlider, SLOT(setValue(int)));

         QSlider *saturationSlider = new QSlider(Qt::Horizontal);
         saturationSlider->setRange(-100, 100);
         saturationSlider->setValue(videoWidget->saturation());
         connect(saturationSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setSaturation(int)));
         connect(videoWidget, SIGNAL(saturationChanged(int)), saturationSlider, SLOT(setValue(int)));

 #if defined(Q_OS_SYMBIAN)
         QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok);
 #endif
         QFormLayout *layout = new QFormLayout;
         layout->addRow(tr("Brightness"), brightnessSlider);
         layout->addRow(tr("Contrast"), contrastSlider);
         layout->addRow(tr("Hue"), hueSlider);
         layout->addRow(tr("Saturation"), saturationSlider);
 #if defined(Q_OS_SYMBIAN)
         layout->addWidget(buttonBox);
 #endif

         QPushButton *button = new QPushButton(tr("Close"));
         layout->addRow(button);

         colorDialog = new QDialog(this);
 #if defined(Q_OS_SYMBIAN)
         connect(buttonBox, SIGNAL(clicked(QAbstractButton*)), colorDialog, SLOT(hide()));
 #endif
         colorDialog->setWindowTitle(tr("Color Options"));
         colorDialog->setLayout(layout);

         connect(button, SIGNAL(clicked()), colorDialog, SLOT(close()));
     }
     colorDialog->show();
 }
 #endif
